home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / p4 / p4-1_2b.lha / p4-1.2b / messages / systest.c < prev    next >
C/C++ Source or Header  |  1993-02-05  |  11KB  |  466 lines
  1. #include "p4.h"
  2.  
  3. extern void slave();
  4.  
  5. int main(argc,argv)
  6.      int argc;
  7.      char **argv;
  8. /*
  9.   Generic SPMD master program .. just creates environment
  10.   and then calls slave, just as the slaves do.
  11.   This probably does NOT do what U want on the iPSC.
  12. */
  13. {
  14.   p4_initenv(&argc,argv);
  15.   p4_create_procgroup();
  16.  
  17.   slave();
  18.  
  19.   p4_wait_for_end();
  20. }
  21.  
  22. #define MAX(a,b) (((a)>(b)) ? (a) : (b))
  23.  
  24. static void Hello();
  25. static void Ring();
  26. static void Stress();
  27. static void Globals();
  28. static int  GlobalReadInteger();
  29.  
  30. extern void synchronize();
  31.  
  32. void slave()
  33. /*
  34.   Test and time aspects of the system.
  35. */
  36. {
  37.   int me = p4_get_my_id();
  38.   int option;
  39.  
  40.   (void) p4_soft_errors(FALSE);  /* This should be the default */
  41.  
  42.   p4_dprintfl(00,"%d is alive on a %s\n",me,p4_machine_type());
  43.   fflush(stdout);
  44.  
  45.   while (1) {
  46.  
  47.     synchronize(1000);
  48.     /* sleep(1); */          /* To allow output to catch up */
  49.  
  50.   again:
  51.     if (me == 0) {
  52.       /* Read user input for action */
  53.       (void) printf("\nOptions: 0=quit, 1=Hello, 2=Ring, 3=Stress, ");
  54.       (void) printf("4=Globals : ");
  55.       (void) fflush(stdout);
  56.     }
  57.     option = GlobalReadInteger();
  58.     if ( (option < 0) || (option > 4) )
  59.       goto again;
  60.  
  61.     switch (option) {
  62.     case 0:
  63.       return;
  64.  
  65.     case 1:
  66.       Hello();
  67.       break;
  68.  
  69.     case 2:
  70.       Ring();
  71.       break;
  72.  
  73.     case 3:
  74.       Stress();
  75.       break;
  76.  
  77.     case 4:
  78.       Globals();
  79.       break;
  80.  
  81.     default:
  82.       p4_error("systest: invalid option", option);
  83.       break;
  84.     }
  85.   }
  86. }
  87.  
  88. static void Hello()
  89. /*
  90.   Everyone exchanges a hello message with everyone else.
  91.   The hello message just comprises the sending and target nodes.
  92. */
  93. {
  94.   int nproc = p4_num_total_ids();
  95.   int me = p4_get_my_id();
  96.   int type = 1;
  97.   int buffer[2], node, *input, length;
  98.  
  99.   if (me == 0) {
  100.     (void) printf("\nHello test ... show network integrity\n----------\n\n");
  101.     (void) fflush(stdout);
  102.   }
  103.  
  104.   for (node = 0; node<nproc; node++) {
  105.     if (node != me) {
  106.       buffer[0] = me;
  107.       buffer[1] = node;
  108.       (void) p4_sendx(type,node,(char *) buffer,sizeof buffer,P4INT);
  109.       input = (int *) NULL;
  110.       (void) p4_recv(&type, &node, (char **) &input, &length);
  111.  
  112.       if ( (input[0] != node) || (input[1] != me) ) {
  113.     (void) fprintf(stderr, "Hello: %d!=%d or %d!=%d\n",
  114.                input[0], node, input[1], me);
  115.     p4_error("Mismatch on hello process ids", node);
  116.       }
  117.  
  118.       (void) p4_dprintfl(00,"Hello from %d to %d\n", me, node);
  119.       (void) fflush(stdout);
  120.     }
  121.   }
  122. }
  123.  
  124. static void Ring()
  125.      /* Time passing a message round a ring */
  126. {
  127.   int me = p4_get_my_id();
  128.   int nproc = p4_num_total_ids();
  129.   int type = 4;
  130.   int left = (me + nproc - 1) % nproc;
  131.   int right = (me + 1) % nproc;
  132.   char *buffer;
  133.   int start, lenbuf, used, max_len, *msg, msg_len;
  134.   double rate;
  135.   p4_usc_time_t start_ustime, end_ustime, used_ustime;
  136.  
  137.   /* Find out how big a message to use */
  138.  
  139.   if (me == 0) {
  140.     (void) printf("\nRing test ... time network performance\n---------\n\n");
  141.     (void) printf("Input maximum message size: ");
  142.     (void) fflush(stdout);
  143.   }
  144.   max_len = GlobalReadInteger();
  145.   if ( (max_len <= 0) || (max_len >= 4*1024*1024) )
  146.     max_len = 512*1024;
  147.   if (me == 0)
  148.     if ( (buffer = p4_shmalloc((unsigned) max_len)) == (char *) NULL)
  149.       p4_error("Ring: failed to allocate buffer",max_len);
  150.  
  151.   type = 5;
  152.  
  153.   lenbuf = 1;
  154.   while (lenbuf <= max_len) {
  155.  
  156.     start = p4_clock();
  157.     start_ustime = p4_ustimer();
  158.     if (me == 0) {
  159.       (void) p4_send(type, left, buffer, lenbuf);
  160.       msg = (int *) NULL;
  161.       (void) p4_recv(&type, &right, (char **) &msg, &msg_len);
  162.       p4_msg_free((char *) msg);
  163.     }
  164.     else {
  165.       msg = (int *) NULL;
  166.       (void) p4_recv(&type, &right, (char **) &msg, &msg_len);
  167.       (void) p4_send(type, left, (char *) msg, msg_len);
  168.       p4_msg_free((char *) msg);
  169.     }
  170.     used = p4_clock() - start;
  171.     used_ustime = p4_ustimer() - start_ustime;
  172.  
  173.     if (used > 0)
  174.       rate = 1.0e-3 * (double) (nproc * lenbuf) / (double) used;
  175.     else
  176.       rate = 0.0;
  177.     if (me == 0)
  178.       (void) printf("len=%d bytes, used=%d ms, used_us=%d rate=%f Mb/s\n",
  179.             lenbuf, used, used_ustime, rate);
  180.     
  181.     lenbuf *= 2;
  182.   }
  183.  
  184.   if (me == 0)
  185.     (void) p4_shfree(buffer);
  186.  
  187. }
  188.  
  189. double ranf()
  190. /* Returns ran # uniform in (0,1) ... probably rather bad statistics. */
  191. {
  192.   static unsigned long seed = 54321;
  193.  
  194.   seed = seed * 1812433253 + 12345;
  195.   return (seed & 0x7fffffff) * 4.6566128752458e-10;
  196. }
  197.  
  198. static void RandList(lo, hi, list, n)
  199.      int lo, hi, *list, n;
  200. /*
  201.   Fill list with n random integers between lo & hi inclusively
  202. */
  203. {
  204.   int i, ran;
  205.   double dran;
  206.  
  207.   for (i=0; i<n; i++) {
  208.     dran = ranf();
  209.     ran = lo + (int) (dran * (double) (hi-lo+1));
  210.     if (ran < lo)
  211.       ran = lo;
  212.     if (ran > hi)
  213.       ran = hi;
  214.     list[i] = ran;
  215.   }
  216. }
  217.  
  218. static void Stress()
  219. /*
  220.   Stress the system by passing messages between a randomly selected
  221.   list of nodes
  222. */
  223. {
  224. #define N_LEN 10
  225.   static int len[N_LEN] = {0,1,2,4,8,4096,8192,16384,32768,65536};
  226.   int me = p4_get_my_id();
  227.   int nproc = p4_num_total_ids();
  228.   int zero = 0;
  229.   int type, lenbuf, i, j, from, to;
  230.   int *list_i, *list_j, *list_n;
  231.   char *buffer;
  232.   int n_stress, mod, *msg, msg_len;
  233.  
  234.   type = 6;
  235.   if (me == 0) {
  236.     (void) printf("\nStress test ... randomly exchange messages\n-----------");
  237.     (void) printf("\n\nInput no. of messages: ");
  238.     (void) fflush(stdout);
  239.   }
  240.   n_stress = GlobalReadInteger();
  241.   if ( (n_stress <= 0) || (n_stress > 100000) )
  242.     n_stress = 1000;
  243.   p4_dprintfl(00,"n_stress=%d\n",n_stress);
  244.  
  245.   lenbuf = n_stress * sizeof(int);
  246.  
  247.   if (!(buffer = p4_shmalloc((unsigned) len[N_LEN-1])))
  248.     p4_error("Stress: failed to allocate buffer", len[N_LEN-1]);
  249.  
  250.   type = 7;
  251.   if (me == 0) { /* Make random list of pairs and message lengths */
  252.     if (!(list_i = (int *) p4_shmalloc((unsigned) lenbuf)))
  253.       p4_error("Stress: failed to allocate list_i",lenbuf);
  254.     if (!(list_j = (int *) p4_shmalloc((unsigned) lenbuf)))
  255.       p4_error("Stress: failed to allocate list_j",lenbuf);
  256.     if (!(list_n = (int *) p4_shmalloc((unsigned) lenbuf)))
  257.       p4_error("Stress: failed to allocate list_n",lenbuf);
  258.  
  259.     RandList((int) 0, nproc-1, list_i, n_stress);
  260.     RandList((int) 0, nproc-1, list_j, n_stress);
  261.     RandList((int) 0, N_LEN-1, list_n, n_stress);
  262.     for (i=0; i<n_stress; i++)
  263.       list_n[i] = len[list_n[i]];
  264.     p4_broadcastx(type, (char *) list_i, lenbuf, P4INT);
  265.     p4_broadcastx(type, (char *) list_j, lenbuf, P4INT);
  266.     p4_broadcastx(type, (char *) list_n, lenbuf, P4INT);
  267.   }
  268.   else {
  269.     list_i = (int *) NULL;
  270.     (void) p4_recv(&type, &zero, (char **) &list_i, &msg_len);
  271.     list_j = (int *) NULL;
  272.     (void) p4_recv(&type, &zero, (char **) &list_j, &msg_len);
  273.     list_n = (int *) NULL;
  274.     (void) p4_recv(&type, &zero, (char **) &list_n, &msg_len);
  275.   }
  276.  
  277.   type = 8;
  278.  
  279.   j = 0;
  280.   mod = (n_stress-1)/10 + 1;
  281.   for (i=0; i < n_stress; i++) {
  282.  
  283.     from   = list_i[i];
  284.     to     = list_j[i];
  285.     lenbuf = list_n[i];
  286.  
  287.     /* P4 can send to self 
  288.     if (from == to)
  289.       continue; */
  290.  
  291.     if ( (me == 0) && (j%mod == 0) ) {
  292.       (void) printf("Stress: test=%ld: from=%ld, to=%ld, len=%ld\n",
  293.             i, from, to, lenbuf);
  294.       (void) fflush(stdout);
  295.     }
  296.  
  297.     j++;  /* Needed when skipping send to self */
  298.  
  299.     if (from == me)
  300.       (void) p4_send(type, to, buffer, lenbuf);
  301.  
  302.     if (to == me) {
  303.       msg = (int *) NULL;
  304.       (void) p4_recv(&type, &from, (char **) &msg, &msg_len);
  305.       p4_msg_free((char *) msg);
  306.       if (msg_len != lenbuf)
  307.     p4_error("Stress: invalid message length on receive",lenbuf);
  308.     }
  309.   }
  310.  
  311.   (void) p4_shfree(buffer);
  312.   if (me == 0) {
  313.     (void) p4_shfree((char *) list_n);
  314.     (void) p4_shfree((char *) list_j);
  315.     (void) p4_shfree((char *) list_i);
  316.   }
  317.   else {
  318.     (void) p4_msg_free((char *) list_n);
  319.     (void) p4_msg_free((char *) list_j);
  320.     (void) p4_msg_free((char *) list_i);
  321.   }
  322. }
  323.  
  324. static int GlobalReadInteger()
  325. /*
  326.   Process zero reads an integer from stdin and broadcasts
  327.   to everyone else
  328. */
  329. {
  330.   int value, *msg, msg_len, type=999,zero=0;
  331.  
  332.   if (p4_get_my_id() == 0) {
  333.     if (scanf("%d", &value) != 1)
  334.       p4_error("failed reading integer value from stdin", -1);
  335.  
  336.     p4_broadcastx(type, (char *) &value, sizeof value,P4INT);
  337.   }
  338.   else {
  339.     msg = (int *) NULL;
  340.     (void) p4_recv(&type, &zero, (char **) &msg, &msg_len);
  341.     value = *msg;
  342.     p4_msg_free((char *) msg);
  343.   }
  344.   return value;
  345. }
  346.  
  347. static int CompareVectors(n, a, b)
  348.      int n;
  349.      double *a, *b;
  350. /*
  351.   Return the no. of differences in two vectors allowing for
  352.   numerical roundoff.
  353. */
  354. {
  355. #define ABS(a)   (((a)>=0 ) ? (a) : -(a))
  356.   int nerrs = 0;
  357.   double diff;
  358.  
  359.   while (n--) {
  360.     diff = *a++ - *b++;
  361.     if (ABS(diff) > 1.0e-8)
  362.       nerrs++;
  363.   }
  364.   
  365.   return nerrs;
  366. }
  367.  
  368. static void Globals()
  369. /*
  370.   Test out functioning of the global operations.
  371. */
  372. {
  373.   int nproc = p4_num_total_ids();
  374.   int me = p4_get_my_id();
  375.   int n, i, start, used, nerrs;
  376.   double *a, *b, rate;
  377.  
  378. #define DO(string, op) \
  379.   start = p4_clock(); \
  380.   if (p4_global_op(33, (char *) a, n, sizeof(double), op, P4DBL)) \
  381.     p4_error("p4_global_op failed",n); \
  382.   used = p4_clock()-start; \
  383.   rate = (used>0) ? n/(1.0e+3 * used) : 0.0; \
  384.   nerrs = CompareVectors(n, a, b); \
  385.   if (me == 0) \
  386.     (void) printf("%s, len=%d, used=%d ms, rate=%f Mop/s, nerrs=%d\n",\
  387.                    string, n, used, rate, nerrs);
  388.  
  389.   if (me == 0) {
  390.     (void) printf("\nGlobal operations test\n----------------------");
  391.     (void) printf("\n\nInput vector length ");
  392.     (void) fflush(stdout);
  393.   }
  394.   n = GlobalReadInteger();
  395.   if ( (n < 0) || (n > 1000000) )
  396.     n = 1000;
  397.  
  398.   if (!(a = (double *) p4_shmalloc((unsigned) (n*sizeof(double)))))
  399.     p4_error("failed to create work space (a)",n);
  400.   if (!(b = (double *) p4_shmalloc((unsigned) (n*sizeof(double)))))
  401.     p4_error("failed to create work space (b)",n);
  402.  
  403.   /* Summation */
  404.  
  405.   for (i=0; i<n; i++) {
  406.     a[i] = i+me;
  407.     b[i] = nproc*i + (nproc*(nproc-1))/2;
  408.   }
  409.   DO("Summation", p4_dbl_sum_op);
  410.  
  411.   /* Maximum */
  412.  
  413.   for (i=0; i<n; i++) {
  414.     a[i] = i+me;
  415.     b[i] = i+nproc-1;
  416.   }
  417.   DO("Maximum", p4_dbl_max_op);
  418.  
  419.   /* Abs Maximum */
  420.  
  421.   for (i=0; i<n; i++) {
  422.     a[i] = i+me - n/2;
  423.     b[i] = MAX(n/2-i, i+nproc-1-n/2);
  424.   }
  425.   DO("Abs Maximum", p4_dbl_absmax_op);
  426.  
  427.   /* Tidy up */
  428.  
  429.   p4_shfree((char *) b);
  430.   p4_shfree((char *) a);
  431. }
  432.  
  433.  
  434. void synchronize(type)
  435.      int type;
  436. /*
  437.   Processes block until all have checked in with process 0
  438.   with a message of specified type .. a barrier.
  439. */
  440. {
  441.   int me = p4_get_my_id();
  442.   int nproc = p4_num_total_ids();
  443.   int zero = 0;
  444.   int *msg;
  445.   int msg_len, node, dummy = type;
  446.  
  447.   if (me == zero) {
  448.     for (node=1; node<nproc; node++){       /* Check in */
  449.       msg = (int *) NULL;
  450.       if (p4_recv(&type, &node, (char **) &msg, &msg_len))
  451.     p4_error("synchronize: recv 1 failed", (int) msg);
  452.       p4_msg_free((char *) msg);
  453.     }
  454.     if (p4_broadcast(type, (char *) &dummy, sizeof dummy))
  455.       p4_error("synchronize: broadcast failed",type);
  456.   }
  457.   else {
  458.     if (p4_send(type, zero, (char *) &me, sizeof me))
  459.       p4_error("synchronize: send failed", type);
  460.     msg = (int *) NULL;
  461.     if (p4_recv(&type, &zero, (char **) &msg, &msg_len))
  462.       p4_error("synchronize: recv 2 failed", (int) msg);
  463.     p4_msg_free((char *) msg);
  464.   }
  465. }    
  466.